cc_library(
    name = "test",
    hdrs = ["include/pcl/test/gtest.h"],
    includes = ["include"],
    deps = [
        "@googletest//:gtest",
        "@pcl//:common",
    ],
)

cc_test(
    name = "2d_test_2d_keypoint_instantiation",
    size = "small",
    srcs = ["2d/keypoint_instantiation.cpp"],
    deps = [
        ":test",
        "@pcl//:2d",
    ],
)

####################################################################################################
# common tests
####################################################################################################
cc_test(
    name = "common_test_wrappers",
    size = "small",
    srcs = ["common/test_wrappers.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_macros",
    size = "small",
    srcs = ["common/test_macros.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_vector_average",
    size = "small",
    srcs = ["common/test_vector_average.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_common",
    size = "small",
    srcs = ["common/test_common.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_pointcloud",
    size = "small",
    srcs = ["common/test_pointcloud.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_parse",
    size = "small",
    srcs = ["common/test_parse.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_geometry",
    size = "small",
    srcs = ["common/test_geometry.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_copy_point",
    size = "small",
    srcs = ["common/test_copy_point.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_transforms",
    size = "small",
    srcs = ["common/test_transforms.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_plane_intersection",
    size = "small",
    srcs = ["common/test_plane_intersection.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_pca",
    size = "small",
    srcs = ["common/test_pca.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_spring",
    size = "small",
    srcs = ["common/test_spring.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_gaussian",
    size = "small",
    srcs = ["common/test_gaussian.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_operators",
    size = "small",
    srcs = ["common/test_operators.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_eigen",
    size = "large",
    srcs = ["common/test_eigen.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_intensity",
    size = "small",
    srcs = ["common/test_intensity.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_generator",
    size = "small",
    srcs = ["common/test_generator.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_common_io",
    size = "small",
    srcs = ["common/test_io.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_copy_make_borders",
    size = "small",
    srcs = ["common/test_copy_make_borders.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_bearing_angle_image",
    size = "small",
    srcs = ["common/test_bearing_angle_image.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_polygon_mesh_concatenate",
    size = "small",
    srcs = ["common/test_polygon_mesh.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_common_point_type_conversion",
    size = "small",
    srcs = ["common/test_point_type_conversion.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_common_point_type_static_member_functions",
    size = "small",
    srcs = ["common/test_point_type_static_member_functions.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_colors",
    size = "small",
    srcs = ["common/test_colors.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_type_traits",
    size = "small",
    srcs = ["common/test_type_traits.cpp"],
    deps = [
        ":test",
    ],
)

cc_test(
    name = "common_test_centroid",
    size = "small",
    srcs = ["common/test_centroid.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

####################################################################################################
# features tests
####################################################################################################
cc_test(
    name = "features_test_features_ptr",
    size = "small",
    srcs = ["features/test_ptr.cpp"],
    deps = [
        ":test",
        "@pcl//:features",
    ],
)

cc_test(
    name = "features_test_gradient_estimation",
    size = "small",
    srcs = ["features/test_gradient_estimation.cpp"],
    deps = [
        ":test",
        "@pcl//:features",
    ],
)

cc_test(
    name = "features_test_rift_estimation",
    size = "small",
    srcs = ["features/test_rift_estimation.cpp"],
    deps = [
        ":test",
        "@pcl//:features",
    ],
)

cc_test(
    name = "features_test_base_feature",
    size = "small",
    srcs = ["features/test_base_feature.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_cppf_estimation",
    size = "small",
    srcs = ["features/test_cppf_estimation.cpp"],
    args = ["colored_cloud.pcd"],
    data = ["colored_cloud.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_normal_estimation",
    size = "small",
    srcs = ["features/test_normal_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_pfh_estimation",
    size = "large",
    srcs = ["features/test_pfh_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_cvfh_estimation",
    size = "small",
    srcs = ["features/test_cvfh_estimation.cpp"],
    args = [
        "bun0.pcd",
        "milk.pcd",
    ],
    data = [
        "bun0.pcd",
        "milk.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:filters",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_ppf_estimation",
    size = "small",
    srcs = ["features/test_ppf_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_shot_estimation",
    size = "small",
    srcs = ["features/test_shot_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_boundary_estimation",
    size = "small",
    srcs = ["features/test_boundary_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_curvatures_estimation",
    size = "small",
    srcs = ["features/test_curvatures_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_spin_estimation",
    size = "small",
    srcs = ["features/test_spin_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

# cc_test(
#     name = "features_test_rsd_estimation",
#     size = "small",
#     srcs = ["features/test_rsd_estimation.cpp"],
#     args = ["bun0.pcd"],
#     data = ["bun0.pcd"],
#     target_compatible_with = select({
#         "@platforms//os:windows": ["@platforms//:incompatible"],
#         "//conditions:default": [],
#     }),
#     deps = [
#         "@pcl//:features",
#         "@pcl//:io",
#         "@pcl//:kdtree",
#         ":test",
#     ],
# )

# cc_test(
#     name = "features_test_grsd_estimation",
#     size = "small",
#     srcs = ["features/test_grsd_estimation.cpp"],
#     args = ["bun0.pcd"],
#     data = ["bun0.pcd"],
#     target_compatible_with = select({
#         "@platforms//os:windows": ["@platforms//:incompatible"],
#         "//conditions:default": [],
#     }),
#     deps = [
#         "@pcl//:features",
#         "@pcl//:io",
#         "@pcl//:kdtree",
#         ":test",
#     ],
# )

cc_test(
    name = "features_test_invariants_estimation",
    size = "small",
    srcs = ["features/test_invariants_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_board_estimation",
    size = "small",
    srcs = ["features/test_board_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_flare_estimation",
    size = "small",
    srcs = ["features/test_flare_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_shot_lrf_estimation",
    size = "small",
    srcs = ["features/test_shot_lrf_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_narf",
    size = "small",
    srcs = ["features/test_narf.cpp"],
    deps = [
        ":test",
        "@flann//:flann_cpp",
        "@pcl//:features",
    ],
)

cc_test(
    name = "features_test_ii_normals",
    size = "medium",
    srcs = ["features/test_ii_normals.cpp"],
    args = ["table_scene_mug_stereo_textured.pcd"],
    data = ["table_scene_mug_stereo_textured.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_moment_of_inertia_estimation",
    size = "small",
    srcs = ["features/test_moment_of_inertia_estimation.cpp"],
    args = ["lamppost.pcd"],
    data = ["lamppost.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_rops_estimation",
    size = "large",
    srcs = ["features/test_rops_estimation.cpp"],
    args = [
        "rops_cloud.pcd",
        "rops_indices.txt",
        "rops_triangles.txt",
    ],
    data = [
        "rops_cloud.pcd",
        "rops_indices.txt",
        "rops_triangles.txt",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_gasd_estimation",
    size = "small",
    srcs = ["features/test_gasd_estimation.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_organized_edge_detection",
    size = "small",
    srcs = ["features/test_organized_edge_detection.cpp"],
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
    ],
)

cc_test(
    name = "features_test_brisk",
    size = "small",
    srcs = ["features/test_brisk.cpp"],
    args = [
        "brisk_descriptors_gt.pcd",
        "brisk_image_gt.pcd",
        "brisk_keypoints_gt.pcd",
    ],
    data = [
        "brisk_descriptors_gt.pcd",
        "brisk_image_gt.pcd",
        "brisk_keypoints_gt.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "@platforms//os:macos": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:features",
        "@pcl//:filters",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:keypoints",
        "@pcl//:search",
    ],
)

####################################################################################################
# filters tests
####################################################################################################
cc_test(
    name = "filters_test_filters_grid_minimum",
    size = "small",
    srcs = ["filters/test_grid_minimum.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:filters",
    ],
)

cc_test(
    name = "filters_test_morphological",
    size = "small",
    srcs = ["filters/test_morphological.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:filters",
    ],
)

cc_test(
    name = "filters_test_filters_functor",
    size = "small",
    srcs = ["filters/test_functor_filter.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:filters",
    ],
)

cc_test(
    name = "filters_test_filters_local_maximum",
    size = "small",
    srcs = ["filters/test_local_maximum.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:filters",
        "@pcl//:octree",
        "@pcl//:search",
    ],
)

cc_test(
    name = "filters_test_uniform_sampling",
    size = "small",
    srcs = ["filters/test_uniform_sampling.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:filters",
    ],
)

cc_test(
    name = "filters_test_farthest_point_sampling",
    size = "small",
    srcs = ["filters/test_farthest_point_sampling.cpp"],
    args = ["bunny.pcd"],
    data = ["bunny.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:filters",
        "@pcl//:io",
    ],
)

cc_test(
    name = "filters_test_convolution",
    size = "small",
    srcs = ["filters/test_convolution.cpp"],
    deps = [
        ":test",
        "@pcl//:filters",
    ],
)

cc_test(
    name = "filters_test_crop_hull",
    size = "large",
    srcs = ["filters/test_crop_hull.cpp"],
    deps = [
        ":test",
        "@pcl//:filters",
    ],
)

cc_test(
    name = "filters_test_filters_bilateral",
    size = "large",
    srcs = ["filters/test_bilateral.cpp"],
    args = ["milk_cartoon_all_small_clorox.pcd"],
    data = ["milk_cartoon_all_small_clorox.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:filters",
        "@pcl//:io",
        "@pcl//:kdtree",
    ],
)

cc_test(
    name = "filters_test_model_outlier_removal",
    size = "small",
    srcs = ["filters/test_model_outlier_removal.cpp"],
    args = ["milk_cartoon_all_small_clorox.pcd"],
    data = ["milk_cartoon_all_small_clorox.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:filters",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:sample_consensus",
    ],
)

cc_test(
    name = "filters_test_filters",
    size = "small",
    srcs = ["filters/test_filters.cpp"],
    args = [
        "bun0.pcd",
        "milk_cartoon_all_small_clorox.pcd",
    ],
    data = [
        "bun0.pcd",
        "milk_cartoon_all_small_clorox.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:filters",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:sample_consensus",
        "@pcl//:segmentation",
    ],
)

cc_test(
    name = "filters_test_clipper",
    size = "small",
    srcs = ["filters/test_clipper.cpp"],
    deps = [
        ":test",
        "@pcl//:filters",
    ],
)

####################################################################################################
# geometry tests
####################################################################################################
cc_test(
    name = "geometry_test_iterator",
    size = "small",
    srcs = [
        "geometry/test_iterator.cpp",
        "geometry/test_mesh_common_functions.h",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_mesh_circulators",
    size = "small",
    srcs = [
        "geometry/test_mesh_circulators.cpp",
        "geometry/test_mesh_common_functions.h",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_mesh_conversion",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_mesh_conversion.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_mesh_data",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_mesh_data.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_mesh_get_boundary",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_mesh_get_boundary.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_mesh_indices",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_mesh_indices.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_mesh",
    size = "small",
    srcs = [
        "geometry/test_mesh.cpp",
        "geometry/test_mesh_common_functions.h",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_polygon_mesh",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_polygon_mesh.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_quad_mesh",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_quad_mesh.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

cc_test(
    name = "geometry_test_triangle_mesh",
    size = "small",
    srcs = [
        "geometry/test_mesh_common_functions.h",
        "geometry/test_triangle_mesh.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:geometry",
    ],
)

####################################################################################################
# io tests
####################################################################################################
cc_test(
    name = "io_test_timestamp",
    size = "small",
    srcs = ["io/test_timestamp.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_io",
    size = "medium",
    srcs = ["io/test_io.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_split",
    size = "small",
    srcs = ["io/test_split.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_iterators",
    size = "small",
    srcs = ["io/test_iterators.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_range_coder",
    size = "small",
    srcs = ["io/test_range_coder.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_grabbers",
    size = "small",
    srcs = ["io/test_grabbers.cpp"],
    args = ["grabber_sequences"],
    data = ["grabber_sequences"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_ply_io",
    size = "small",
    srcs = ["io/test_ply_io.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_point_cloud_image_extractors",
    size = "small",
    srcs = ["io/test_point_cloud_image_extractors.cpp"],
    deps = [
        ":test",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_buffers",
    size = "small",
    srcs = ["io/test_buffers.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:io",
    ],
)

cc_test(
    name = "io_test_octree_compression",
    size = "small",
    srcs = ["io/test_octree_compression.cpp"],
    args = ["milk_color.pcd"],
    data = ["milk_color.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:io",
        "@pcl//:octree",
    ],
)

####################################################################################################
# ml tests
####################################################################################################
cc_test(
    name = "ml_test_ml_kmeans",
    size = "small",
    srcs = ["ml/test_kmeans.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:ml",
    ],
)

####################################################################################################
# octree tests
####################################################################################################
cc_test(
    name = "octree_test_octree",
    size = "large",
    srcs = ["octree/test_octree.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:octree",
    ],
)

cc_test(
    name = "octree_test_octree_iterator",
    size = "small",
    srcs = ["octree/test_octree_iterator.cpp"],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:octree",
    ],
)

####################################################################################################
# outofcore tests
####################################################################################################
cc_test(
    name = "outofcore_test_outofcore",
    size = "medium",
    srcs = ["outofcore/test_outofcore.cpp"],
    deps = [
        ":test",
        "@boost.foreach",
        "@pcl//:common",
        "@pcl//:outofcore",
    ],
)

####################################################################################################
# registration tests
####################################################################################################
cc_test(
    name = "registration_test_warps",
    size = "small",
    srcs = ["registration/test_warps.cpp"],
    deps = [
        ":test",
        "@pcl//:registration",
    ],
)

cc_test(
    name = "registration_test_correspondence_estimation",
    size = "small",
    srcs = ["registration/test_correspondence_estimation.cpp"],
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:registration",
    ],
)

cc_test(
    name = "registration_test_registration",
    size = "small",
    srcs = ["registration/test_registration.cpp"],
    args = [
        "bun0.pcd",
        "bun4.pcd",
        "milk_color.pcd",
    ],
    data = [
        "bun0.pcd",
        "bun4.pcd",
        "milk_color.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:registration",
        "@pcl//:search",
    ],
)

cc_test(
    name = "registration_test_ndt",
    size = "small",
    srcs = ["registration/test_ndt.cpp"],
    args = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    data = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:io",
        "@pcl//:registration",
    ],
)

cc_test(
    name = "registration_test_sac_ia",
    size = "small",
    srcs = ["registration/test_sac_ia.cpp"],
    args = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    data = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:io",
        "@pcl//:registration",
    ],
)

cc_test(
    name = "registration_test_registration_api",
    size = "medium",
    srcs = [
        "registration/test_registration_api.cpp",
        "registration/test_registration_api_data.h",
    ],
    args = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    data = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:registration",
    ],
)

cc_test(
    name = "registration_test_correspondence_rejectors",
    size = "small",
    srcs = ["registration/test_correspondence_rejectors.cpp"],
    args = ["bunny.pcd"],
    data = ["bunny.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:registration",
    ],
)

cc_test(
    name = "registration_test_fpcs_ia",
    size = "small",
    srcs = [
        "registration/test_fpcs_ia.cpp",
        "registration/test_fpcs_ia_data.h",
    ],
    args = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    data = [
        "bun0.pcd",
        "bun4.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:registration",
        "@pcl//:search",
    ],
)

cc_test(
    name = "registration_test_kfpcs_ia",
    size = "medium",
    srcs = [
        "registration/test_kfpcs_ia.cpp",
        "registration/test_kfpcs_ia_data.h",
    ],
    args = [
        "office1_keypoints.pcd",
        "office2_keypoints.pcd",
    ],
    data = [
        "office1_keypoints.pcd",
        "office2_keypoints.pcd",
    ],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:registration",
        "@pcl//:search",
    ],
)

####################################################################################################
# sample_consensus tests
####################################################################################################
cc_test(
    name = "sample_consensus_test_sample_consensus_plane_models",
    size = "small",
    srcs = ["sample_consensus/test_sample_consensus_plane_models.cpp"],
    args = ["sac_plane_test.pcd"],
    data = ["sac_plane_test.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:io",
        "@pcl//:sample_consensus",
    ],
)

cc_test(
    name = "sample_consensus_test_sample_consensus_quadric_models",
    size = "small",
    srcs = ["sample_consensus/test_sample_consensus_quadric_models.cpp"],
    deps = [
        ":test",
        "@pcl//:sample_consensus",
    ],
)

cc_test(
    name = "sample_consensus_test_sample_consensus_line_models",
    size = "small",
    srcs = ["sample_consensus/test_sample_consensus_line_models.cpp"],
    deps = [
        ":test",
        "@pcl//:sample_consensus",
    ],
)

####################################################################################################
# search tests
####################################################################################################
cc_test(
    name = "search_test_kdtree_search",
    size = "large",
    srcs = [
        "search/precise_distances.h",
        "search/test_kdtree.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:kdtree",
        "@pcl//:search",
    ],
)

cc_test(
    name = "search_test_flann_search",
    size = "large",
    srcs = [
        "search/precise_distances.h",
        "search/test_flann_search.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:kdtree",
        "@pcl//:search",
    ],
)

cc_test(
    name = "search_test_organized_search",
    size = "small",
    srcs = [
        "search/precise_distances.h",
        "search/test_organized.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:kdtree",
        "@pcl//:search",
    ],
)

cc_test(
    name = "search_test_octree_search",
    size = "small",
    srcs = [
        "search/precise_distances.h",
        "search/test_octree.cpp",
    ],
    deps = [
        ":test",
        "@pcl//:common",
        "@pcl//:octree",
        "@pcl//:search",
    ],
)

# cc_test(
#     name = "search_test_search",
#     size = "large",
#     srcs = [
#         "search/precise_distances.h",
#         "search/test_search.cpp",
#     ],
#     args = ["table_scene_mug_stereo_textured.pcd"],
#     data = ["table_scene_mug_stereo_textured.pcd"],
#     target_compatible_with = select({
#         "@platforms//os:windows": ["@platforms//:incompatible"],
#         "//conditions:default": [],
#     }),
#     deps = [
#         "@pcl//:io",
#         "@pcl//:kdtree",
#         "@pcl//:search",
#         ":test",
#     ],
# )

cc_test(
    name = "search_test_organized_index",
    size = "small",
    srcs = [
        "search/precise_distances.h",
        "search/test_organized_index.cpp",
    ],
    args = ["office1.pcd"],
    data = ["office1.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:io",
        "@pcl//:search",
    ],
)

####################################################################################################
# surface tests
####################################################################################################
cc_test(
    name = "surface_test_marching_cubes",
    size = "large",
    srcs = ["surface/test_marching_cubes.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_moving_least_squares",
    size = "small",
    srcs = ["surface/test_moving_least_squares.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_gp3",
    size = "small",
    srcs = ["surface/test_gp3.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_organized_fast_mesh",
    size = "small",
    srcs = ["surface/test_organized_fast_mesh.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_grid_projection",
    size = "large",
    srcs = ["surface/test_grid_projection.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_ear_clipping",
    size = "small",
    srcs = ["surface/test_ear_clipping.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_poisson",
    size = "small",
    srcs = ["surface/test_poisson.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_convex_hull",
    size = "large",
    srcs = ["surface/test_convex_hull.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:filters",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)

cc_test(
    name = "surface_test_concave_hull",
    size = "small",
    srcs = ["surface/test_concave_hull.cpp"],
    args = ["bun0.pcd"],
    data = ["bun0.pcd"],
    target_compatible_with = select({
        "@platforms//os:windows": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),
    deps = [
        ":test",
        "@pcl//:features",
        "@pcl//:filters",
        "@pcl//:io",
        "@pcl//:kdtree",
        "@pcl//:sample_consensus",
        "@pcl//:search",
        "@pcl//:surface",
    ],
)
